#include <sstream>
#include "Exception.h"

using namespace game_engine::utils;

Exception::Exception(const string& msg1) 
{
    size_t len = msg1.size();
    if (len > MSG_SIZE) 
    {
        len = MSG_SIZE;
    }
    memcpy_s(msg, sizeof msg, msg1.data(), len);
    msg[len] = 0;
}

Exception::Exception(const char* m) 
{
    strncpy_s(msg, sizeof msg, m, MSG_SIZE);
    msg[MSG_SIZE] = 0;
}

Exception::Exception(const Exception& src) 
    : exception() 
{
    strcpy_s(msg, sizeof msg, src.msg);
}

Exception& Exception::operator=(const Exception& src) 
{
    strcpy_s(msg, sizeof msg, src.msg);
    return *this;
}

const char* Exception::what() const throw() 
{
    return msg;
}

Exception::~Exception(void)
{
}

RuntimeException::RuntimeException(INT32 stat)
    : Exception(formatMessage(stat)) 
{
}

RuntimeException::RuntimeException(const string& msg1)
    : Exception(msg1) 
{
}

RuntimeException::RuntimeException(const RuntimeException& src)
    : Exception(src) 
{
}

RuntimeException& RuntimeException::operator=(const RuntimeException& src) 
{
    Exception::operator=(src);
    return *this;
}

string RuntimeException::formatMessage(INT32 stat) 
{
    string s1("RuntimeException : return code = ");
    stringstream flux;
    flux << stat;
    return (s1 + flux.str());
}

RuntimeException::~RuntimeException(void)
{
}

NullPointerException::NullPointerException(const string& msg1)
    : RuntimeException(msg1) 
{
}

NullPointerException::NullPointerException(const NullPointerException& src)
    : RuntimeException(src) 
{
}

NullPointerException& NullPointerException::operator=(
    const NullPointerException& src) 
{
    RuntimeException::operator=(src);
    return *this;
}

NullPointerException::~NullPointerException(void)
{
}

IllegalArgumentException::IllegalArgumentException(const string& msg1)
    : RuntimeException(msg1) 
{
}

IllegalArgumentException::IllegalArgumentException(
    const IllegalArgumentException& src)
    : RuntimeException(src) 
{
}

IllegalArgumentException& IllegalArgumentException::operator=(
    const IllegalArgumentException& src) 
{
    RuntimeException::operator=(src);
    return *this;
}

IllegalArgumentException::~IllegalArgumentException(void)
{
}

IOException::IOException(void)
    : Exception("IO exception") 
{
}

IOException::IOException(INT32 stat)
    : Exception(formatMessage(stat)) 
{
}


IOException::IOException(const string& msg1)
    : Exception(msg1) 
{
}

IOException::IOException(const IOException& src)
    : Exception(src) 
{
}

IOException& IOException::operator=(const IOException& src) 
{
    Exception::operator=(src);
    return *this;
}

string IOException::formatMessage(INT32 stat) 
{
    string s1("IO Exception : return code = ");
    stringstream flux;
    flux << stat;
    return (s1 + flux.str());
}

IOException::~IOException(void)
{
}

NoSuchElementException::NoSuchElementException()
    : Exception("No such element") 
{
}

NoSuchElementException::NoSuchElementException(const string& msg)
    : Exception(msg) 
{
}

NoSuchElementException::NoSuchElementException(const NoSuchElementException& src)
    : Exception(src) 
{
}

NoSuchElementException& NoSuchElementException::operator=(
    const NoSuchElementException& src) 
{
    Exception::operator=(src);
    return *this;
}

NoSuchElementException::~NoSuchElementException(void)
{
}

IllegalStateException::IllegalStateException()
    : Exception("Illegal state") 
{
}

IllegalStateException::IllegalStateException(const IllegalStateException& src)
    : Exception(src) 
{
}

IllegalStateException& IllegalStateException::operator=(
    const IllegalStateException& src) 
{
    Exception::operator=(src);
    return *this;
}

IllegalStateException::~IllegalStateException(void)
{
}

ParserException::ParserException(void)
    : Exception("Parser exception") 
{
}

ParserException::ParserException(const string &msg)
    : Exception(msg) 
{
}

ParserException::ParserException(const ParserException& src)
    : Exception(src) 
{
}

ParserException& ParserException::operator=(
    const ParserException& src) 
{
    Exception::operator=(src);
    return *this;
}

ParserException::~ParserException(void)
{
}

